bigA：DeepSeek Harness 的 Agent Skill
bigA 是面向 DeepSeek Harness (dSH) 的 Agent Skill，由社区开发（仓库路径 kobenfang/bigA，MIT 许可证），与 DeepSeek 或幻方无官方从属关系。它通过 ClawHub 发布，供 OpenClaw 用户搜索安装，命令为 `npx clawhub search biga` 和 `npx clawhub install biga`。bigA 在 package.json 中声明了 DSH bundle patch，引入 `./cordis.patch.yml` 补丁文件，作为 DSH bundle 的一部分扩展 dsh 能力。资料未披露具
Read Moredsh-plugin-development: Cross-Host Portable DSH Plugin Development and Audit Skills
dsh-plugin-development is an MIT-licensed Agent Skill (v0.2.0-beta.1) maintained by w2112515, designed for the creation, implementation, packaging, review, and diagnostics of DeepSeek Harness plugins. The same canonical directory can be shared across Codex, Claude Code, and DSH, with optional bundle adapters supporting profile-level installation and reversible uninstallation. The skill distinguishes between three modes—dynamic Cordis, workspace packages, and installable bundles—and provides corresponding acceptance evidence, along with a check-artifact helper script. Example for installing a bundle: `dsh plugin --profile web add` with an official release TGZ or `github:w2112515/dsh-plugin-development#v0.2.0-beta.1`. This is a community Beta project; please review the source code and license before installation.
Read MoreUnified Management of AI Skills on DeepSeek Harness Settings Page with dsh-skill-manager
# 翻译结果： dsh-skill-manager is maintained by sulfide2085 under the MIT License. It adds a skill management section to the DSH Web settings page, merges skills from the DSH / Agents / Codex / Claude directories, enables or disables skills dynamically via SKILL.md and .disabled files, and supports installation via local ZIP packages (≤64 MiB) and GitHub repository archives. This article verifies the installation command, default repository, restrictions and security considerations based on the directory page, README and source code.
Read More# Install Plugin Development and Auditing Skills for DeepSeek Harness with dsh-plugin-development
`dsh-plugin-development` is an MIT-licensed open-source Agent Skill maintained by w2112515. It is used to design, implement, package, review and diagnose DeepSeek Harness plugins, with an optional bundle adapter included. It first differentiates between dynamic Cordis plugins, workspace packages and installable bundles, then executes according to a fixed process from discovery to verification. Integrated packages are not within its scope. The directory installation command is `dsh plugin add github:w2112515/dsh-plugin-development`, and the current version is v0.2.0-beta.1. This is an unofficial project; the plugin runs with the permissions of the current dsh process, so you should check the source code and license before installation.
Read MoreInstall a RN Performance Optimization Manual for AI Assistant with react-native-best-practices
Callstack split the RN performance e-book into Agent Skill react-native-best-practices, which covers FPS, TTI, package volume, memory and native modules. This article is verified against the official SKILL.md and the repository README: 29 references cover how to triage, how to install the skills CLI, as well as list virtualization, React DevTools measurement and the usage of Android R8. The core is to measure before making changes.
Read More### 贴合技术文档场景的标准译法： `vercel-cli-with-tokens: Authenticate Vercel CLI via Tokens, No More `vercel login` Required`
`vercel-cli-with-tokens` is one of the Skills in Vercel's official agent-skills collection. It teaches Agents to call the Vercel CLI using the `VERCEL_TOKEN` instead of `vercel login`. It discovers tokens via environment variables and `.env` files, uses `VERCEL_ORG_ID` and `VERCEL_PROJECT_ID` in pairs, defaults to preview deployments, and supports overriding environment variables, build logs and domain names. It is suitable for CI and non-interactive automation scenarios, and complements `deploy-to-vercel`. It is forbidden to write Tokens into the `--token` parameter.
Read More# Vercel React View Transitions: Adding Native Transition Animations to React Following the Official Workflow
`vercel-react-view-transitions` is an official Agent Skill from Vercel Labs, teaching Cursor, Claude Code and Codex to use React's ViewTransition and `addTransitionType` to implement native page transitions. It can be installed via `npx skills add`. It covers shared element transitions, Suspense reveal, list reordering and route direction animations, with instructions for Next.js App Router included. ViewTransition is currently available in the React Canary channel; App Router has built-in support and no longer requires installing `react@canary`. Unsupported browsers will simply not display the animations.
Read MoreAudit the documentation against Vercel writing guidelines using writing-guidelines
This is an introduction to Vercel Labs' Agent Skill "writing-guidelines": it reviews the tone, structure, readability and typesetting of documents and prose in accordance with the Vercel Writing Guidelines. The following details are covered: its attribution and version, the mechanism of pulling the remote `command.md` before each review, the coverage of over 80 rules, the `file:line` output format, as well as the installation and triggering methods using `npx skills add` in tools such as Cursor, Claude Code and Codex, plus notes including network dependencies and Vercel site-specific conventions.
Read More# vercel-optimize: Optimize Cost and Performance of Vercel Projects Based on Production Metrics First
`vercel-optimize` is an official Agent Skill from vercel-labs/agent-skills (SKILL.md 1.2.0) that performs cost and performance audits for deployed projects. The workflow involves first collecting metrics from the past 14 days, then identifying routes using a deterministic script, and finally modifying code. It has the most complete support for Next.js/SvelteKit, is available for Nuxt, and has limited support for Astro. The installation command is: `npx skills add vercel-labs/agent-skills --skill vercel-optimize`. You need Node.js 20+, Vercel CLI v53+, and have completed login/link operations; route-level sorting additionally requires Observability Plus.
Read MoreZero Skill: Automatically Discover and Invoke Paid External Tools on a Per-Use Basis When the Agent Says "Cannot Do It"
Zero is a search engine and payment layer designed for AI Agents. Official Skills will intervene when the model is about to say "cannot do" or ask users to register for APIs on their own, using zero search / get / fetch / review to discover and call external capabilities (x402 / MPP) on a pay-per-use basis. Users can log in with a unified wallet, eliminating the need to apply for individual Keys for each service. This article verifies the installation methods (Claude Code, Codex, Gemini CLI, Cursor) and cost control points based on the official repository, SKILL.md, zero.xyz and the npm package @zeroxyz/cli (version 1.30.0).
Read MoreVariant Analysis: Locate a Bug and Eliminate All Similar Ones
Trail of Bits’ variant-analysis has turned the daily variant analysis work of security engineers into an Agent Skill: after confirming a vulnerability, it extracts the root cause, calibrates with precise patterns, searches the entire codebase while relaxing only one condition at a time, and finally triages and leaves CI rules. This article explains the five-step workflow, the selection of ripgrep, Semgrep and CodeQL, as well as the installation and invocation methods of Claude Code, Codex and Cursor, based on the official SKILL.md, plugin README and policy documents.
Read MoreSemgrep-Rule-Creator: Using Agent to Write Testable Semgrep Security Rules
`semgrep-rule-creator` is an Agent Skill launched by Trail of Bits, used to create custom Semgrep rules that can detect security vulnerabilities, bug patterns and code patterns. Instead of running existing rule sets, it forces the Agent to produce rules following the workflow of test-first, AST analysis, priority given to taint mode, and optimization only after all tests pass. This article organizes the installation method, seven-step workflow, eval taint example and usage boundaries based on the official SKILL.md, plugin README and skill market description.
Read More# Property-Based Testing: Trail of Bits Turns Property Testing into Reusable Agent Skills
Trail of Bits' property-based-testing is a cross-language skill guide for property testing that includes smart contracts. It teaches agents to identify encoding/decoding, parsing, normalization, and contract invariants, write tests based on properties like round-trip and idempotence, and distinguish between test errors and real bugs when tests fail. Based on the official SKILL.md, plugin READMEs and market repositories, the article explains the installation of Claude Code / Codex, the `npx skills add` command, and reproducible examples such as Hypothesis.
Read MoreDifferential Review: Trail of Bits formalizes PR security differential review into an executable workflow
Differential-review is an Agent Skill released by Trail of Bits, which conducts security-focused reviews on PRs, commits and diffs: it classifies tasks by risk rather than line count, uses git history to detect regressions, quantitatively calculates the blast radius, treats missing tests as a higher risk factor, and enforces the output of a Markdown report with line numbers and attack scenarios. This article checks the official SKILL.md, plugin README and documentation website, explaining what problems it solves, how to install it in Claude Code / Codex / the general Skill catalog, as well as three official usage scenarios and inapplicable scenarios.
Read MoreUsing firecrawl-build-search: Start from queries and write web discovery into product code
`firecrawl-build-search` is an official Agent Skill for Firecrawl, specifically designed to connect the `/search` endpoint to product code: the functionality starts from queries instead of URLs. It first discovers, ranks and selects sources, then decides whether to hydrate the content or hand it over to `/scrape`. This article cross-verifies installation commands, authentication fields, one-step/two-step call differences, and error-prone upgrade paths such as paper indexing and developer indexing based on GitHub's SKILL.md, repository README, officialskills.sh and docs.firecrawl.dev.
Read MoreIntegrate Web Search, Crawling and Browser Interaction into Application Code with firecrawl-build
`firecrawl-build` is the official application integration entry Skill of Firecrawl, located in the `firecrawl/skills` repository. It targets scenarios where products, agents or workflows need to obtain webpage data through code. It first clarifies what data to fetch and how to fetch it, then routes the requirements to `/scrape`, `/search` or `/interact`, instead of mixing "help me search a page in the current session" with "integrate Firecrawl into the backend". This article checks the installation commands, environment variables, SDK, sub-skill division, smoke test, and the boundaries with CLI/Workflow skills against the SKILL.md, repository README and official documentation.
Read MoreSandbox SDK Skill: Let AI Securely Execute Untrusted Code with Cloudflare Sandbox
### Official Translation: This article introduces Cloudflare's sandbox-sdk Agent Skill: it explains how to guide Cursor / Claude Code / Codex to use the Sandbox SDK to execute untrusted code in Workers isolated containers. The article verifies the current status of the project being split into sandbox-stable, sandbox-next, and sandbox-migrate-to-next in August 2026, and provides official installation methods, minimal Worker examples and lifecycle, as well as restrictions such as transport and image alignment.
Read More# workers-best-practices Skill: Review and Write Cloudflare Workers in Accordance with Production Agreements
Cloudflare's official workers-best-practices Skill is used to review and write Workers code in accordance with production conventions: it pulls current documentation and types first, then checks `wrangler.jsonc`, streaming responses, floating promises, global state, secrets and observability. This article verifies the installation method, rule list and anti-patterns based on the original GitHub content and the official best practice page, and explains that Durable Objects, Workflows and the wrangler CLI need to switch to other Skills in the same repository.
Read More# 翻译结果 Durable Objects Skill: Build Chatrooms, Collaboration and Stateful RPC According to Official Conventions
### 正式翻译（符合技术文档译法，兼顾准确性与行业惯例）： The official Cloudflare durable-objects Skill is used to create and review Durable Objects: sharding by chat rooms, game sessions or tenants, routing via `getByName`, carrying stateful edge logic with SQLite, RPC, alarms and WebSockets, and testing with Vitest. This article verifies the installation, configuration and anti-patterns against the original GitHub source and official documentation, and notes that while the Skill example still uses migrations, the current getting-started documentation recommends declaring SQLite classes via `exports`.
Read More# Cloudflare Skill: A Progressive Loading Full Platform Manual for AI
Cloudflare's official cloudflare Skill is a cross-platform entry point for Agents: users can select the right primitive among Workers, Pages, KV/D1/R2, Workers AI, Network & Security, and Terraform/Pulumi via a decision tree, then load 63 product reference directories on demand. This article cross-verifies the installation method, binding syntax and typical usage based on the original GitHub text and official documentation, and notes that reference materials may expire — for example, the example model @cf/meta/llama-3.1-8b-instruct has been discontinued as of 2026-05-30, and the quota limits and model names shall be subject to the latest Cloudflare documentation.
Read MoreConnect 1000+ External Apps to Agents with Composio Skill
Composio's official Skill teaches AI programming assistants to connect to 1000+ external applications such as Gmail, Slack, GitHub, Notion via a unified CLI and SDK. This article verifies the installation commands, the search→link→execute workflow, user-isolated sessions, as well as the usage boundaries of OAuth and Triggers based on SKILL.md, the repository README and docs.composio.dev.
Read More# Voltagent Best Practices: Incorporating VoltAgent Architecture Conventions into Agent Skills
`voltagent-best-practices` is an architecture quick-reference Skill officially maintained by VoltAgent, covering trade-offs between Agent and Workflow, src directory conventions, memory default values, Hono/Elysia/serverless servers, and VoltOps observation access. This article cross-verifies the installation and activation methods, code snippets and precautions based on the official SKILL.md, VoltAgent documentation and VoltAgent/skills repository, and explains the division of labor between it and the create-voltagent scaffolding Skill.
Read More# create-voltagent: Initialize AI Agent Project in Accordance with VoltAgent Specification Using Official Skill
`create-voltagent is an Agent Skill officially maintained by VoltAgent, which guides users to create TypeScript AI Agent projects via the `create-voltagent-app` CLI or complete manual steps. This article is cross-verifies based on the official `SKILL.md`, Quick Start and VoltAgent/skills repository: it covers the installation and activation methods, Hono/Elysia and six model providers, directory and environment variable conventions, weather Tool and reimbursement approval Workflow examples, as well as its differences from the general "project scaffolding" Skill.
Read More`find-bugs: Let AI scan the current branch for bugs and security issues according to the checklist`
find-bugs is an Agent Skill publicly released by the Sentry Engineering Team in the getsentry/skills repository, which is used to review the changes made in a local branch relative to the default branch. It executes in five stages: obtaining the complete diff via Git and GitHub CLI, mapping the attack surface, going through 11 security checklists such as Injection, XSS, authentication, and IDOR item by item, verifying false positives, and finally generating a report with evidence, while explicitly stating that it will not modify any code. It can be installed via the Claude Plugin Marketplace or `npx skills add`, and is compatible with tools that support SKILL.md such as Cursor, Claude Code, and Codex.
Read More# 正确的翻译结果如下： Configure `uv`, `ruff` and `ty` for Python Projects with the `modern-python` Skill
Trail of Bits rebranded its internal cookiecutter-python template as Agent Skill modern-python, replacing pip, flake8, black, mypy and pre-commit with uv, ruff, ty, pytest and prek. This article verifies the installation method, minimal project, PEP 723 scripts and migration steps from requirements.txt / setup.py based on the official SKILL.md and documentation site, and notes limitations such as Python 3.11+ requirement and the beta status of ty.
Read More# shadcn Skill: Let AI Search, Install and Combine shadcn/ui Components According to Project Configuration
shadcn is the official Agent Skill for shadcn/ui. After installation, it will read the project's components.json, inject the framework, aliases, installed components, icon library and underlying primitives via `shadcn info --json`, then search, install, debug and stitch together UIs according to the official combination rules. It was released alongside CLI v4 in March 2026, and can be added to tools like Cursor, Claude Code and Codex via `pnpm dlx skills add shadcn/ui`, preventing assistants from writing components that do not match the project based on memory.
Read More# 翻译结果： firecrawl-cli: Let AI Agents Scrape, Search, Crawl and Map Web Pages via CLI
firecrawl-cli is the official Firecrawl Agent Skill (located in the directory skills/firecrawl-cli, with the frontmatter named firecrawl). It enables assistants such as Cursor, Claude Code, and Codex to search, scrape, map, crawl and interact with web pages via the Firecrawl CLI, with results saved in .firecrawl/ in Markdown/JSON format. Based on the official SKILL.md and CLI documentation, this article explains the installation and authentication procedures, the workflow of search→scrape→map→crawl→interact, as well as key notes including credits and rate limits for users without an API key.
Read MoreImprove Codebase Architecture: Let AI Conduct Architecture Review First Before Deciding Where to Modify
Matt Pocock’s `improve-codebase-architecture` is a user-invoked Agent Skill: it scans for shallow modules and leaky seams based on recent commit hotspots, filters candidates using deletion tests, drafts deepening opportunities into an off-repo HTML report (built with Tailwind + Mermaid), then conducts a grilling on the item you select. It does not modify business code, with the output being testable and navigable architectural decisions, before proceeding to to-spec, to-tickets and implementation stages. It is suitable for regular technical debt governance and structural health checks before major overhauls, rather than automated refactoring.
Read MoreUse Matt Pocock's TDD Skills for Vertical Slice Test-Driven Development
This article introduces Matt Pocock's tdd Skill constrained programming Agent that follows vertical slice TDD: first agree on the public seams, then write exactly one failing test and just enough implementation code to pass it each time. Based on GitHub's SKILL.md, tests.md, mocking.md and aihero.dev, the article sorts out the testing standards, three anti-patterns, mocking boundaries, installation methods for Cursor / Claude Code / Codex, as well as restrictions such as refactoring being moved to code review and not suitable for glue code.
Read Moregrill-me: Before you start coding, let the Agent ask you thoroughly first
grill-me is the user-triggered entry point in Matt Pocock’s skill set: before the Agent takes action, it conducts round-by-round questioning via a decision tree to refine unformed ideas into actionable commitments. It is stateless, does not write files, and the topics do not have to be related to code. The actual interview loop is located in the grilling directory within the same repository, and simply deploying grill-me often fails to run properly. Based on the official SKILL.md and aihero.dev documentation, this article organizes the installation method, question format, the division of labor between grill-with-docs and wayfinder, as well as common pitfalls such as passive nodding, overly broad scope, and unloaded Skill.
Read MoreAdding Analytics: Let AI Agent Integrate PostHog into Web Applications According to Standard Procedures
# 官方正式翻译结果： adding-analytics is a SKILL.md in the awesome-cursor-skills repository, which formalizes the process of integrating PostHog into web applications: identify the framework, install posthog-js/posthog-node, initialize the Provider, supplement pageview tracking for SPAs, manage keys using environment variables, and add custom events, Feature Flags and session replays as needed. This article cross-verifies based on the original Skill content and official documents of PostHog, Cursor, Claude Code and Codex, explains the installation directory, reproducible examples, as well as the differences between variable names, React package paths, pageview default behavior, input desensitization and other aspects compared with current official documents.
Read MoreDatabase Design: Let AI Agents Design Table Relationships, Indexes, Constraints and ORM According to Specifications
# SKILL.md for Database Design (Included in awesome-cursor-skills) ## Overview This is a database modeling skill collected in awesome-cursor-skills, which covers entity identification, table relationships, constraints, indexes, and Prisma/Drizzle configuration. ## Six-step Workflow Verified against the official original text, the workflow is as follows: 1. **Entity Identification**: Extract core business entities from requirements 2. **Define Entity Attributes**: Clarify each entity's fields and data types 3. **Establish Table Relationships**: Map one-to-one, one-to-many, and many-to-many associations between entities 4. **Set Up Constraints**: Add NOT NULL, unique, primary key, foreign key and other constraints to ensure data integrity 5. **Design Indexes**: Create appropriate indexes to optimize query performance 6. **Generate ORM Configuration**: Write standardized Prisma or Drizzle schema files based on the designed database structure ## PostgreSQL Example & Installation Method ### Example Code ```sql -- Sample PostgreSQL table creation script CREATE TABLE users ( id SERIAL PRIMARY KEY, username VARCHAR(50) UNIQUE NOT NULL, email VARCHAR(255) UNIQUE NOT NULL, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); CREATE TABLE posts ( id SERIAL PRIMARY KEY, title VARCHAR(255) NOT NULL, content TEXT, author_id INTEGER NOT NULL, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (author_id) REFERENCES users(id) ON DELETE CASCADE ); -- Sample index CREATE INDEX idx_posts_author_id ON posts(author_id); ``` ### Prisma Configuration Example ```prisma generator client { provider = "prisma-client-js" } datasource db { provider = "postgresql" url = env("DATABASE_URL") } model User { id Int @id @default(autoincrement()) username String @unique @db.VarChar(50) email String @unique @db.VarChar(255) createdAt DateTime @default(now()) @db.Timestamptz() posts Post[] } model Post { id Int @id @default(autoincrement()) title String @db.VarChar(255) content String? authorId Int author User @relation(fields: [authorId], references: [id], onDelete: Cascade) createdAt DateTime @default(now()) @db.Timestamptz() } ``` ### Drizzle Configuration Example ```typescript import { pgTable, serial, varchar, text, integer, timestamp, unique } from 'drizzle-orm/pg-core'; export const users = pgTable('users', { id: serial('id').primaryKey(), username: varchar('username', { length: 50 }).notNull(), email: varchar('email', { length: 255 }).notNull(), createdAt: timestamp('created_at').defaultNow().notNull() }, (table) => { return { usernameUnique: unique().on(table.username), emailUnique: unique().on(table.email), } }); export const posts = pgTable('posts', { id: serial('id').primaryKey(), title: varchar('title', { length: 255 }).notNull(), content: text('content'), authorId: integer('author_id').notNull(), createdAt: timestamp('created_at').defaultNow().notNull() }, (table) => { return { authorRef: foreignKey({ columns: [table.authorId], foreignColumns: [users.id] }).onDelete('cascade'), authorIndex: index('idx_posts_author_id').on(table.authorId) } }); ``` ## Supplementary Role of AI Programming This skill makes up for the shortcomings of AI programming in schema design: 1. Provides standardized, step-bysted operating specifications to avoid AI from generating incomplete or non-compliant database schemas 2. Combines business requirements with technical implementation, helping AI transform abstract business logic into a practical, production-ready database structure 3. Standardizes the connection between logical design and physical implementation, ensuring the consistency of schema design from demand analysis to ORM code generation ## Usage Restrictions 1. **PostgreSQL Dialect Limitation**: The current skill takes PostgreSQL as the only demonstration database, and may need to be adjusted when adapting to MySQL, SQL Server and other relational databases 2. **ORM Scope Limitation**: Only covers Prisma and Drizzle two mainstream Node.js ORM frameworks, and is not applicable to ORM tools in other programming languages or non-mainstream Node.js ORMs 3. **Basic Database Design Only**: Focuses on conventional relational database modeling, and does not cover special scenarios such as distributed databases, columnar storage databases, and non-relational databases 4. Requires manual verification: AI generated content still needs developers to check for business matching, performance bottlenecks and compliance issues in actual production environments
Read More# Adding Stripe: Enabling AI Agents to Integrate Stripe Payments via Standard Procedures
# Adding Stripe is a community Agent Skill in awesome-cursor-skills, compiling Stripe Checkout, subscription Webhooks and Customer Portal into a 7-step checklist. Based on the original SKILL.md text and cross-referenced with the documentation for Stripe Checkout, Webhooks, Billing Portal and Cursor Skills, this article explains what problem it solves, how to install it in Cursor / Claude Code / Codex, as well as usage notes such as signature verification, Customer ID and API version.
Read MoreUse recording-browser-flow-as-test: Walk through the process in the browser and automatically generate Playwright tests
# Introduction to `recording-browser-flow-as-test` in spencerpauly/awesome-cursor-skills: This tool allows users to walk through user workflows step-by-step using Cursor's built-in browser, record accessibility tree information via `browser_snapshot`, and then generate Playwright tests that use stable locators such as `getByRole` and `getByLabel`. This article verifies the installation commands, prerequisites, recording steps, assertion and hardening suggestions, as well as inapplicable scenarios such as 2FA and verification codes.
Read More# Accessibility Auditing: Performing Accessibility Audits Using Cursor Browser's ARIA Tree
### Translated Abstract: Introducing accessibility-auditing in spencerpauly/awesome-cursor-skills: Leveraging Cursor's built-in browser tools including `browser_navigate`, `browser_snapshot` and `browser_press`, it conducts audits on the page ARIA tree covering missing labels, semantic HTML, keyboard navigation order, ARIA misuses and color contrast issues. It generates a categorized report with Critical/Warnings/Passed statuses and can directly modify the source code. The document also explains the installation methods via `.cursor/skills` directory or `npx skills add` command, as well as applicable scenarios and compliance review considerations.
Read MoreLet Agent fix itself until all tests pass with grinding-until-pass
### 介绍 This article introduces `grinding-until-pass` from spencerpauly/awesome-cursor-skills: It enables the Agent to independently fix issues until tests, builds, or lint checks pass via the `fix→run→check` loop. We verify that the steps follow the official SKILL.md rules, including iterating within 10 times, fixing one thing at a time, and prohibiting deleting tests or suppressing errors. We also explain the installation methods using `npx skills` or copying the skill to `.cursor/skills`, along with target command examples and advanced usage of Cursor Hooks. This skill is suitable for scenarios such as large-scale refactoring, dependency upgrades, and clearing failed builds after merging branches; manual intervention is required for slow tests or when design changes are needed.
Read More# remotion-best-practices: Let AI Write Remotion Programmatic Videos According to Specifications
This article introduces Remotion's official Agent Skill `remotion-best-practices`: as the main entry point, it routes sub-skills such as project creation, Markup, maps, subtitles, Studio, rendering, and upgrades to agents including Cursor, Claude Code, and Codex. Based on the official `SKILL.md` and documentation, this guide explains installation commands, frame-driven animation specifications (`useCurrentFrame` + `interpolate`), media and resource conventions, as well as preview/frame extraction usage, helping users avoid rendering pitfalls when using AI to program videos.
Read MoreUse supabase-postgres-best-practices to help AI programming assistants master Postgres skills
### 翻译结果： Introduce the Agent Skill `supabase-postgres-best-practices` maintained by Supabase: A tool designed for platforms such as Cursor and Claude Code, it restricts AI when writing SQL, modifying tables and troubleshooting performance based on eight priority rules covering query performance, connection management, RLS, schema and other aspects. The article verifies the official installation commands, rule structure and typical correct and incorrect examples, and explains how it cooperates with Supabase MCP.
Read More# agents-sdk Skill: Build Stateful AI Agents on Cloudflare
### Official Translation: This article introduces Cloudflare's official agents-sdk Skill: it guides AI assistants to prioritize retrieving Agents documentation, and correctly build stateful Agents on Workers / Durable Objects, covering features such as `setState`, `@callable RPC`, scheduling, Workflows, MCP and React hooks. The article provides installation steps, agents dependency verification, wrangler configuration and a Counter example, and marks precautions such as decorators, migrations and experimental features.
Read MoreFrontend Performance Audit with web-perf Skill: Integrate Core Web Vitals into Agent Workflow
### Official Cloudflare Agent Skill `web-perf` Introduction This tool leverages Chrome DevTools MCP to audit Core Web Vitals (LCP, INP, CLS) alongside FCP, TBT, and Speed Index, and troubleshoots issues including render-blocking resources, network dependency chains, layout shifts, and caching problems. The article explains its positioning, five-stage workflow, installation methods in tools such as Cursor, Claude Code, and Codex, mandatory configurations for MCP, typical prompt words and output formats, and reminds users to verify thresholds against current official documentation and avoid hardcoding conclusions without an MCP.
Read MoreWrangler Skill: Enable AI Assistants to Deploy Cloudflare Workers Correctly
This article introduces Cloudflare's official Agent Skill "wrangler": it guides AI programming assistants to prioritize retrieving official documentation and configuration schemas before deploying and managing resources such as Workers, KV, R2, D1, etc., to avoid outdated commands and incorrect bindings. The article covers the positioning of the Skill, its core capabilities, installation and activation in tools including Cursor, Claude Code, Codex and other platforms, typical examples of wrangler.jsonc and commonly used commands, as well as precautions such as key security and local remote binding.
Read MoreOne-click Preview and Deployment of AI-written Projects with deploy-to-vercel
# Official Vercel Labs Agent Skill `deploy-to-vercel` Introduction This article introduces Vercel Labs' official Agent Skill `deploy-to-vercel`: how to install it in tools such as Cursor, Claude Code, and Codex; how to automatically select between `git push`, `vercel deploy`, or an unauthenticated sandbox script based on git remote, `.vercel` association, and CLI login status; how to generate a Preview URL by default; and how to try to advance the project to a long-term automatically deployable link state. All commands and branch logic in this article are verified against the official `SKILL.md (v3.0.0)` and the `skills.sh` installation instructions.
Read MorePerform a Standard Audit on AI-Generated UI Using Web-Design-Guidelines
### Official Translation: Introduce Vercel Labs' Agent Skill "web-design-guidelines": This tool audits UI accessibility, UX and performance compliance in accordance with Web Interface Guidelines. Explain its attribution and version, the mechanism of pulling remote specifications before each audit, the coverage of over 100 rules, the file:line output format, as well as the installation and triggering methods using `npx skills add` in tools such as Cursor / Claude Code / Codex. Also list applicable scenarios and precautions such as internet dependency.
Read MoreUse composition-patterns to let AI write maintainable React composite code
# Translation Result: This article introduces Vercel's Agent Skill **composition-patterns (vercel-composition-patterns, v1.0.0)**: it uses composite components, lifted state and explicit variants to avoid the proliferation of boolean props, covering four types of rules: architecture, state, implementation patterns and React 19 API. The article explains how to install it into tools such as Cursor / Claude Code / Codex via `npx skills`, and provides official example-level refactoring and Context interface usage cases.
Read MoreAdd a React Performance Goalkeeper for AI Programming with react-best-practices
### Official Vercel Agent Skill `react-best-practices` (formal name: `vercel-react-best-practices`) Introduction This skill organizes React/Next.js performance optimization experience into a rule set sorted by impact severity. The current `SKILL.md` contains 70 rules covering 8 categories, with priority given to eliminating request waterfalls and bundle bloat. Details include source attribution, the 8 rule categories, installation command (`npx skills add … --skill vercel-react-best-practices`), triggering usage in tools like Cursor, Claude Code and Codex, as well as applicable scenarios and notes on names and versions.
Read MoreUse notion-knowledge-capture to precipitate AI conversations into a Notion knowledge base
### 译文： Introduce OpenAI's curated Agent Skill "notion-knowledge-capture": This tool relies on Notion's official MCP, and organizes decisions and steps from conversations with tools like Cursor, Codex into linkable Notion pages according to templates such as Wiki, How-To, ADR, and FAQ. The article verifies the installation command, the MCP access methods for Codex/Cursor/Claude Code, as well as the official decision capture and How-To sample workflow.
Read MoreIntegrate Figma Designs into AI Programming Workflows with OpenAI's Official Figma Skill
This article introduces the Figma Skill curated by OpenAI: how it cooperates with Figma MCP (mcp.figma.com) to obtain design context, screenshots, variables and resources, and converts design nodes into project code through a fixed workflow. It verifies the installation methods ($skill-installer / directory copy), the MCP configuration of Codex (FIGMA_OAUTH_TOKEN, RMCP client), the mandatory toolchain (get_design_context → get_metadata → get_screenshot), and the link-driven prompt writing method, which is suitable for developers who carry out design-to-code collaboration in Codex, Cursor and Claude Code.
Read MoreUse Transcribe Skill to convert meeting recordings and podcasts into searchable text
### 正式翻译： This article introduces OpenAI's official Agent Skill `transcribe`: Based on `gpt-4o-mini-transcribe` and `gpt-4o-transcribe-diarize`, it converts audio and video files into text, with support for speaker diarization and known speaker prompts. It explains the installation directories and activation methods in Codex, Cursor and Claude Code, provides reproducible examples including fast transcription with the bundled CLI and `diarized_json` output, and lists precautions such as the 25MB file size limit, automatic chunking for long audio, and the fact that the diarize model does not support prompts.
Read MoreUsing OpenAI Speech Skill to synthesize reusable voice from text
# Official OpenAI Curated Skill: speech This article introduces the OpenAI Agent Skills-powered speech skill that calls the OpenAI Audio API. It allows users to synthesize text into narration, product voiceovers, IVR audio and accessible reading audio via the built-in CLI. The article covers the installation method, configuration of the OPENAI_API_KEY, usage of the `speak` and `speak-batch` commands, default models and built-in voices, as well as limitations including single audio length, speech rate and custom voices.
Read MoreIntegrate Official Documentation for AI Programming Assistants with openai-docs Skill: Say Goodbye to Outdated APIs and Fabricated Parameters
# Official curated Skill "openai-docs" from OpenAI: Retrieve and cite the latest documentation via Developer Docs MCP (search/fetch/OpenAPI) This skill covers API usage, Codex manual self-knowledge, model selection and prompt engineering. It explains the paired installation with Docs MCP across platforms including Codex, Cursor and Claude Code, typical prompt usage scenarios, and precautions such as read-only document access and narrow-scope migration, to alleviate the issues of outdated documentation and parameter hallucinations in AI programming assistants.
Read Morepython-tdd-with-uv: Let AI Agent Write Python in Red-Green-Refactor Cycle
### Translation: This article introduces `python-tdd-with-uv`: a SKILL.md from spencerpauly/awesome-cursor-skills that teaches AI Agents to conduct Python Test-Driven Development (TDD) using uv. It verifies the official capabilities of uv (including its project initiation with pytest, vertical slice red-green-refactor workflow, and uv run conventions), covers the installation directory and activation method under Cursor/Claude Code/Codex, provides reproducible command examples and test structure samples, and explains the applicable scenarios and limitations of this skill.
Read More# Standard Conventional Commits Written with the `writing-commit-messages` Skill
### Translated English Abstract: This article introduces the `writing-commit-messages` section in spencerpauly/awesome-cursor-skills: how to use Agent Skill to constrain commit messages to follow Conventional Commits specifications (including type prefixes, scopes, body content, and BREAKING CHANGE sections). It verifies the rules in SKILL.md, good and bad examples, commit granularity requirements, as well as the installation methods for Cursor skills: manually installing to the `.cursor/skills/` directory, and using `npx skills add` to install to both Cursor and Claude Code. This guide is suitable for teams that need standardized collaboration and automated changelog generation.
Read MoreUsing kubernetes-deploying Skill: Let AI Agents Generate Kubernetes Deployment Manifests According to Specifications
### 翻译结果： `kubernetes-deploying` from spencerpauly/awesome-cursor-skills is an Agent Skill designed for Kubernetes deployments. It encapsulates best practices including Deployment, Service, Ingress, ConfigMap, Secret, health checks, release strategies and HPA into the SKILL.md file, enabling AI programming tools such as Cursor, Claude Code and Codex to generate standardized manifests and work with common kubectl commands. This article introduces its capabilities, installation and activation methods, typical usage scenarios and usage notes based on official documentation.
Read MoreHand Over Production Incident Response Process to AI Agent via Incident-response Skill
# Incident Response in spencerpauly/awesome-cursor-skills This project packages the SEV grading, stopgap mitigation, internal and external communication, and 48-hour blameless post-incident review workflow for production incidents into an installable `SKILL.md`. It has verified official workflows and post-incident review templates, and provides enabling methods via `npx skills` or by copying to `.cursor/skills/` for use in Cursor, Claude Code, and Codex CLI, making it suitable for SRE/DevOps on-duty scenarios.
Read MoreGenerate bitmap assets in the coding workflow using Codex's imagegen Skill
# Introduction to OpenAI Codex System-level Skill `imagegen` This skill enables generation and editing of bitmap assets including photos, illustrations, mockups and sprites within coding conversations via either the built-in `image_gen` command or an explicit CLI. Details including default auto-installation location, two operating modes, prompt templates, save path conventions, applicable boundaries and official CLI examples are provided to facilitate directly integrating visual assets into project repositories.
Read Moreplugin-creator: One-click Scaffold Codex Plugin with Official Skill
# Official OpenAI System Skill Plugin-Creator: Guide This article introduces OpenAI's official Skill Plugin-Creator system, detailing how to scaffold plugin directories for Codex/ChatGPT, generate the required `.codex-plugin/plugin.json` file, create placeholders for skills, hooks, MCP, apps as needed, and write configurations to local or repository-level `marketplace.json`. It also covers conversational invocation methods (`$plugin-creator` / `@plugin-creator`), command parameters for `create_basic_plugin.py`, conventions for manifest and marketplace fields, applicable scenarios, and common pitfalls.
Read More# skill-installer: The "Package Manager" for Installing Skills on Codex
Skill-installer is a system Skill pre-installed by OpenAI alongside Codex, used to install Skills to `$CODEX_HOME/skills` (default path: `~/.codex/skills`) from the official curated/experimental catalog or any GitHub repository path. Based on the official SKILL.md and Codex documentation, this article explains how to use `skill-installer` to list and install Skills, covers script parameters, private repository and download fallback strategies, as well as the boundaries of local testing and plugins distribution.
Read MoreBuild ChatGPT Apps with chatgpt-apps Skill: MCP Server + Widget UI
### 正式翻译结果： ### Introduction to OpenAI's official curated Skill chatgpt-apps: How to scaffold, refactor and troubleshoot ChatGPT Apps SDK applications (MCP server + Widget UI) following a docs-first workflow. The article verifies the capabilities of Skills, application prototype classification, upstream example priority, usage boundaries between MCP Apps bridge and window.openai, as well as the installation and activation methods in Codex and Cursor. It also provides prompt examples for paired use with openai-docs and local joint debugging steps for Developer Mode.
Read MoreTurn Notion research into cited structured documents with notion-research-documentation
### Official English Translation: This article introduces the OpenAI curated skill `notion-research-documentation`: under the premise that Notion MCP has been connected, it enables cross-page retrieval and evidence synthesis within Notion, and generates cited documents in templates such as briefings, summaries, comparisons, and full reports. It follows the official SKILL.md instructions for installation and activation (including Codex's `$skill-installer` and Cursor's skills directory), covers the official five-step workflow, competitive product comparison examples, as well as precautions such as permissions, timeliness, and warehouse deprecation.
Read MoreUse notion-spec-to-implementation to split Notion PRD into executable plans
### 译文： This article introduces OpenAI curated skill `notion-spec-to-implementation`: with the support of Notion MCP, it parses PRD/functional specifications into implementation plans, 1-2 day granular tasks and progress write-back, realizing the connection between Spec ↔ Plan ↔ Tasks. The article verifies the installation methods (Codex $skill-installer and Skills directory of Cursor/Claude Code), MCP configuration (mcp.notion.com), workflows and official API examples, and explains applicable scenarios and common precautions.
Read MoreEquip Agents with "Eyes" Using Screenshot Skill: Desktop Screenshot and Visual QA
# OpenAI Curated Screenshot Agent Skill This skill enables agents to capture full-screen, window-specific, or pixel-region screenshots across macOS, Linux and Windows for visual analysis and UI validation. It prioritizes tools like Figma and Playwright first, with system-level screenshots as a fallback. The article details its save path rules, official installation methods (using Codex's $skill-installer and placing files in Cursor/Claude Code directories), cross-platform script usage, as well as considerations around permissions, dependencies and multi-monitor setups, helping to build a complete front-end visual QA workflow that connects design mockups, browser pages and desktop applications.
Read More`playwright-interactive: Using Persistent JS_REPL for UI Iteration and Debugging`
# Introduction to OpenAI's Featured Skill: playwright-interactive This skill enables persistent handling of Playwright/Electron via js_repl, allowing rapid iterative UI debugging on local web and Electron applications. It also supports completing QA checklists, functional validation, visual QA and viewport adaptation following official workflows. This article details the installation steps, pre-configuration requirements, typical code snippets, as well as notes such as the possible removal of js_repl in the current Codex, and makes a comparison with the CLI-oriented Playwright Skill.
Read More# Figma-Create-Design-System-Rules: Develop Project-Specific Design System Rules for Agents
This is an introduction to `figma-create-design-system-rules` in the openai/skills curated catalog: On the premise of connecting Figma MCP, it analyzes the codebase and generates project-level design system rules, constraining component paths, Design Tokens, styling solutions and the Figma-to-code workflow, and writes them into `CLAUDE.md`, `AGENTS.md` or `.cursor/rules/figma-design-system.mdc` respectively, to alleviate problems such as random use of spacing, hard-coded colors, and repeated creation of components when AI implements UI. The article verifies the installation method, five-step workflow and precautions.
Read MoreUse figma-generate-design to reverse-generate pages from code into Figma
This article introduces the `figma-generate-design` Skill in the OpenAI curated and Figma MCP ecosystems: on the premise that Figma MCP is connected and the target file has a design system, it writes application pages or multi-block layouts into Figma in the form of component instances and Tokens, and forcibly cooperates with `figma-use`. The article verifies official processes including plugin installation (Cursor / Claude Code / Codex), npx skills installation method, block assembly and parallel calibration of `generate_figma_design`, as well as the boundaries between adjacent Skills such as `figma-implement-design` and Code Connect.
Read MoreVisualize Security Responsibility Topology from Git History Using security-ownership-map
# Security-Ownership-Map: An OpenAI Curated Agent Skill Security-Ownership-Map is an OpenAI curated Agent Skill that constructs human-file bipartite graphs and covariation clustering based on Git history, calculates the Bus Factor of sensitive code, and supports output in CSV/JSON formats (with optional Neo4j/Gephi exports). This article introduces its positioning, installation and activation, usage of `run_ownership_map` and `query_ownership`, sensitive code rules and applicable boundaries, which is suitable for enterprise security teams to conduct inventory of ownership drift and orphaned sensitive code.
Read More# 翻译结果： security-threat-model: Let Agent perform threat modeling based on code repositories
### Official Translation: This article introduces OpenAI's curated Skill **security-threat-model**: it enumerates trust boundaries, assets, attacker capabilities and abuse paths based on repository evidence, and outputs a structured Markdown threat model. The article verifies the official workflow, reporting contract, installation and activation methods of Codex/Cursor/Claude Code (including the Trail of Bits plugin), as well as typical prompt words and usage boundaries.
Read More`render-deploy`: Analyze codebase, generate Blueprint, and deploy applications to Render
This article introduces OpenAI Curated Agent Skill `render-deploy`: it analyzes the codebase to generate a render.yaml Blueprint, or directly creates a single service via Render MCP, and provides a deep link to the Dashboard to complete the deployment. It verifies the installation methods (npx skills / Codex skill-installer), the MCP configuration for Cursor/Claude/Codex, the heuristic guidelines for choosing between Blueprint and Direct Creation, as well as precautions such as Git remote, image service restrictions, `sync:false` for secrets, port binding and other matters, and complements deployment-related Skills like Vercel/Cloudflare.
Read MoreOne-click Deployment of Frontend Projects to Netlify with the netlify-deploy Skill
### Translated Abstract: This article introduces the OpenAI curated skill `netlify-deploy`: it uses the Netlify CLI (`npx netlify`) to complete authentication, site association/creation, dependency installation, and preview/production deployment. It explains the installation methods in the Agent Skills directories of Cursor, Codex, Claude Code and other platforms, provides official workflow command examples, notes for `netlify.toml`, as well as usage suggestions such as sandbox networking and key management.
Read MoreJupyter Notebook: Official OpenAI Skill to Enable Agents to Generate Jupyter Notebooks in Compliance with Specifications
OpenAI's curated Skill jupyter-notebook targets two scenarios of experimental and tutorial Jupyter Notebooks. It generates structurally standardized .ipynb files through bundled templates and the new_notebook.py scaffolding script, and is also equipped with experiment/tutorial mode guides and quality checklists. This article verifies the official SKILL.md and repository scripts, and introduces the installation methods (Codex $skill-installer, Cursor .cursor/skills), typical commands and Agent prompts, as well as applicable scenarios and precautions.
Read MoreLinear Skill: Let AI Agents Directly Operate Linear Tickets, Not Just Write Code
### 译文： Officially selected by OpenAI: Skill Linear, which enables Agents to read, create and update Issues, projects and team workflows via Linear MCP. This article introduces its positioning, core capabilities, installation steps for Codex/Cursor, typical usage scenarios such as Bug triage and Standup synchronization, as well as precautions including OAuth and rate limits.
Read Moreyeet: Official OpenAI Skill, Run stage → commit → push → Create PR in one sentence
yeet is a curated Agent Skill maintained by OpenAI in the openai/skills repository. It only uses the GitHub CLI to complete git add, commit, push and create or update a Pull Request in one go when the user explicitly requests it. This article verifies its workflow based on the official SKILL.md: automatically creating a branch from the default branch, perceiving PR templates, avoiding duplicate PRs, and creating new PRs as Drafts. It also explains the installation methods and typical trigger phrases in Codex and Cursor. It is suitable for GitHub developers who want to hand over the final mile of Git release to AI Agents.
Read More# migrate-to-codex: Official Migration Skill to One-Click Move Claude Code Configuration to Codex
OpenAI's official Skill `migrate-to-codex` can convert Claude Code's instructions, Skills, Hooks, MCPs and sub-Agents into Codex's standard directory structure, supports scan, plan, dry-run and verification, and outputs a migration report. This article introduces installation and activation, typical commands, as well as the complementary relationship and limitations between it and Codex /import.
Read More# Slack-GIF-Creator: Let AI Help You Make GIFs Compliant with Slack Specifications
Slack-gif-creator is an Agent Skill in Anthropic's official Skills repository. It encapsulates constraints such as GIF dimensions, frame rate and color specifically for the Slack scenario, and provides a GIFBuilder assembly tool, validators for verification, as well as guides on easing and animation concepts. This article introduces its positioning, core capabilities, as well as installation methods and typical usage in AI programming tools such as Cursor and Claude Code, helping developers quickly produce GIFs that can be uploaded to Slack using natural language.
Read MoreDetailed Explanation of canvas-design Skill: Incorporating Design Philosophy into AI to Generate PNG/PDF Static Visual Works
Canvas-design is a creative Agent Skill in Anthropic's official Skills repository. It adopts a two-step workflow of "first formulating design philosophy, then expressing it on the canvas, and finally conducting secondary refinement", and outputs .md manifesto and .png/.pdf visual finished products. This article verifies its core capabilities, canvas-fonts font resources, installation methods in Cursor and Claude Code, as well as typical usages such as posters and brand visuals and copyright considerations based on the official SKILL.md.
Read More# brand-guidelines: Let AI Agent Automatically Apply Anthropic Official Brand Specifications
`brand-guidelines` is an official Anthropic Skills example that writes brand colors (#141413, #d97757, etc.) and Poppins/Lora font rules into `SKILL.md`, enabling Agents to automatically align with visual specifications when generating PPTs, documents, and HTML. Based on verification against the official `SKILL.md` and the repository README, this article introduces its positioning, color palette details, installation methods for Cursor/Claude Code/Claude.ai, typical prompts, as well as reusable patterns and precautions for building enterprise self-built design specification Skills.
Read More# unit-test-generator: Let AI Agent Automatically Generate Unit Tests According to Specifications
The unit-test-generator is a community example Skill in the JackyST0/awesome-agent-skills repository. It standardizes the workflow of "identifying code, analyzing boundaries, selecting frameworks, and generating test cases" via SKILL.md, and supports multiple programming languages including Python, JavaScript/TypeScript, Java, Go, Rust, etc., as well as testing frameworks such as pytest, Jest, JUnit, etc. This article introduces its positioning, core capabilities, installation methods on platforms like Cursor/Codex, official divide function examples, applicable scenarios such as test case supplementation and team specification implementation, as well as usage notes.
Read More### 正式译法（适配技术文档场景）： Setting up CI: Let AI Agents Help You Build GitHub Actions CI/CD Pipelines
# setup-ci from awesome-cursor-skills: A beginner-friendly DevOps skill for GitHub Actions This skill detects Node.js, Python, Go and other projects via the SKILL.md specification, then generates a `ci.yml` workflow that includes linting, testing, type checking and optional deployment. It emphasizes the use of `npm ci`, dependency caching and secret security best practices. This article covers installation (deploying to `.cursor/skills/`), typical usage and precautions, and is ideal for quickly setting up CI/CD for new projects.
Read MoreFour Perspectives on One PR: Practical Combat of Parallel Code Review Skills
### 翻译版本1（正式技术文档风格）： `parallel-code-review` is a Cursor-Native Skill in the `awesome-cursor-skills` repository. It leverages the Task tool to launch four read-only explore sub-agents simultaneously to review the same code diff across four dimensions: security, performance, correctness, and readability, before the main agent deduplicates and consolidates the results into a hierarchical report. After verifying against the official `SKILL.md`, this article introduces the installation methods (via `.cursor/skills/` or `npx skills`), four-step workflow (scope the changes, conduct parallel review, synthesize the report, and optional repair), as well as applicable scenarios and limitations. ### 翻译版本2（更贴合开源社区表述习惯）： `parallel-code-review` is a Cursor-native skill hosted in the `awesome-cursor-skills` repo. It uses the Task tool to spin up four read-only explore sub-agents at once to audit the same code diff from four perspectives: security, performance, correctness, and readability. The main agent will then deduplicate and merge the feedback into a tiered report. This article first cross-checks with the official `SKILL.md`, then walks through the installation steps (either via `.cursor/skills/` directory or `npx skills`), the four-stage workflow (select the changes to review, run parallel audits, compile the final report, and apply fixes optionally), plus the applicable use cases and current constraints of the skill.
Read More# Systematic Debugging: Integrate Structured Debugging Methodology into Skill to Enable AI Troubleshooting Without Blind Guesses
### 正式翻译： The `systematic-debugging` repository comes from `awesome-cursor-skills`. It will write the five-step debugging process of reproduction, isolation, hypothesis, verification and repair into `SKILL.md`, covering git bisect, binary search and minimal reproduction. This article introduces its origin, core capabilities, installation methods in AI programming tools such as Cursor, as well as typical usages such as automatic triggering and explicit invocation via `/systematic-debugging`, helping developers constrain Agents to troubleshoot based on evidence rather than randomly modifying code.
Read More# 翻译结果： Architecture Decision Records: Documenting Technical Decisions with Agent Skill
### Translation: Let me introduce the *architecture-decision-records* skill included in awesome-cursor-skills: it teaches AI Agents to document technical decisions in accordance with ADR specifications, covering their backgrounds, alternative options and justifications. The skill covers when to write ADRs, template structures, a six-step workflow, installation methods and typical prompt examples, helping teams turn architectural governance from verbal agreements into retrievable decision logs.
Read MoreAdding Auth: Enabling AI Agents to Integrate with Auth.js Authentication via Standard Procedures
*adding-auth* has been included in awesome-cursor-skills. The integration of Auth.js v5 with Next.js App Router has been organized into an 8-step workflow: dependency installation, setting up AUTH_SECRET, auth.ts configuration, OAuth setup, Route Handler implementation, login UI and route protection, and optional database Adapter. Verified against the official SKILL.md and Auth.js documentation, this article introduces the installation method and typical usage, suitable for web developers who need to quickly integrate OAuth and sessions.
Read More# cloudflare-deploy: Let AI Agents Deploy Applications to Cloudflare Edge Network
`cloudflare-deploy` is an Agent Skill under the OpenAI openai/skills curated directory. It guides AI Agents to complete full-stack deployments on Cloudflare, including Workers, Pages, and services like KV/D1/R2, via decision trees and reference documents. This article verifies the official SKILL.md, introduces its differences from vercel-deploy, the installation methods for Codex/Cursor, the Wrangler authentication process and typical deployment commands, which is suitable for developers who need edge Serverless and multi-cloud deployments.
Read More# figma-implement-design: Official OpenAI Skill that 1:1 restores Figma design drafts to production-grade code
**figma-implement-design** is an OpenAI-curated Agent Skill that works with the Figma MCP to translate design nodes into deliverable UI code within repositories. This article introduces its seven-step workflow, boundaries with other Skills such as figma-use, prerequisites for the MCP, as well as installation and typical usage in tools like Cursor (/add-plugin figma) and Codex ($skill-installer), helping developers shorten the Design-to-Code iteration cycle.
Read MoreOpenAI Official Security-Best-Practices: Performing Security Reviews of AI According to Languages and Frameworks
OpenAI has provided the `security-best-practices` Skill in the `curated` directory of the openai/skills repository. It includes 10 security specifications for common frameworks in Python, JavaScript/TypeScript and Go, and supports secure-by-default coding, passive inspection and structured security reporting. This article introduces its workflow, references library, Codex/Cursor installation methods and typical prompts, to help developers embed verifiable security review capabilities into AI-assisted programming.
Read More### 版本1（面向技术用户，贴合原文语境）： `vercel-deploy`: Let AI Agents Deploy Projects to Vercel with One Click ### 版本2（更地道的技术文档译法）： `vercel-deploy`: Enable AI Agents to One-Click Deploy Projects to Vercel
Vercel-deploy is a Vercel deployment Skill in the OpenAI Skills curated directory, which guides AI Agents to one-click deploy applications to Vercel. It uses preview deployment by default; prioritizes Vercel CLI, and automatically downgrades to the deploy.sh script when not logged in, and can return previewUrl and claimUrl without prior account configuration. It supports automatic detection of frameworks such as Next.js, Nuxt, Astro, etc., and is applicable to tools such as Cursor, Codex CLI, and Claude Code.
Read MoreDrive Real Browsers via Terminal: Getting Started with OpenAI's Official Playwright Skill
OpenAI's featured Skill "playwright" wraps the Playwright Agent CLI into a terminal browser automation workflow: opening pages, taking snapshots to obtain element references, filling forms and clicking, taking screenshots, and debugging with Trace. Verified based on the official SKILL.md, this article introduces the installation methods (Codex skill-installer, Cursor .cursor/skills), the usage of the wrapper script, typical command examples, as well as precautions such as re-snapshotting when refs fail and not writing @playwright/test by default. It is suitable for E2E exploratory automation and UI process troubleshooting scenarios.
Read Moregh-fix-ci: Use GitHub CLI to let AI help you debug failed CI checks on PRs
If your CI fails before a PR is merged, do you have to switch back and forth between the Actions page and your terminal to check logs? The officially curated OpenAI skill `gh-fix-ci` is specifically designed for GitHub Actions failure troubleshooting: it pulls PR checks and run logs via the GitHub CLI, uses bundled scripts to automatically extract error snippets, provides a repair plan first, and waits for approval before you modify the code. This article introduces the positioning of this skill, the usage of `inspect_pr_checks.py`, as well as the installation and enabling methods in tools such as Codex and Cursor.
Read Moregh-address-comments: Structured Processing of GitHub PR Review Comments with Agent Skill
gh-address-comments is a curated Skill by OpenAI Codex. It pulls all review and inline comments of the current branch PR via gh CLI and GraphQL scripts, summarizes them with serial numbers for users to select the entries to handle, and then hands them over to the Agent for code modification. This article introduces its three-step workflow, the capabilities of fetch_comments.py, the installation methods of Codex and Cursor, as well as applicable scenarios and precautions under the human-in-the-loop design.
Read More# doc-coauthoring: Use a three-stage structured workflow to let Agents help you write clear technical specifications and decision documents
Doc-coauthoring is a documentation co-creation Skill in Anthropic's official Skills repository, targeting structured writing scenarios such as technical specifications, decision documents, RFCs, and PRDs. Instead of generating a full article at one time, it guides the Agent through three phases: context collection, section-by-section polishing, and reader testing. It first supplements background information through meta-questions and information dumping, then conducts brainstorming, screening, drafting and iterative revision by chapter, and finally uses a context-free Claude to simulate reader questions to identify blind spots in the document. This article introduces its core capabilities, installation methods in Cursor and Claude Code, as well as typical interaction examples and applicable boundaries for writing decision docs.
Read More# web-artifacts-builder: Using React Stack to Enable Agents to Deliver Deployable Frontend HTML Artifacts
Anthropic’s official Skill `web-artifacts-builder` builds complex multi-component web artifacts using React 18, TypeScript, Vite, Tailwind and shadcn/ui. The `init-artifact.sh` initializes the scaffold and pre-installs over 40 components, while `bundle-artifact.sh` packages the project into a self-contained `bundle.html`. This article covers the installation and activation methods for tools like Claude Code and Cursor, a four-step workflow, and applicable scenarios, helping AI Agents deliver web pages following modern front-end engineering practices.
Read MoreTheme Factory: One-click skin changing for slides, documents and landing pages with Agent Skill
### 翻译结果： This article introduces Anthropic's official theme-factory Skill: it includes 10 preset themes (color schemes and fonts), which can apply unified styles to slides, documents, reports and HTML landing pages, and also supports custom themes. Based on the official SKILL.md and repository structure, this article explains the installation methods (CLI, manual copying, Claude Code plugin), standard skin-changing process and typical prompt examples, which is suitable for developers who need to unify the style in AI design workflows.
Read MoreLet AI Truly Excel at Writing Excel: Detailed Explanation of Anthropic's Official xlsx Skill
xlsx is an official Anthropic Agent Skill dedicated to handling reading and writing of spreadsheet files such as .xlsx/.csv, formula modeling and data cleaning, and also serves as the implementation reference behind Claude's document capabilities. This article introduces its core capabilities (division of labor among openpyxl/pandas/markitdown, formula recalculation via recalc.py, and financial model specifications), as well as the installation, activation methods and typical usage scenarios in Cursor, Claude Code and Claude.ai, to help developers enable AI to directly deliver auditable spreadsheets.
Read MoreSkill for PPTX: Let AI Agents Truly Learn to Create PowerPoint Presentations
### 译文1（标准科技文档译法，适配海外技术社区表达）： > The official Anthropic PPTX Skill supports creation, editing and reading of `.pptx` and `.potx` files, with supporting scripts including `pptxgenjs`, OOXML decompression and editing utilities, and `validate.py`, as well as triple-layer QA. This article introduces its positioning, core capabilities, installation method in Cursor / Claude Code, typical usage scenarios and precautions for template filling, validation and visual QA. --- ### 译文2（更贴合海外开发者文档的口语化译法）： > Anthropic's official PPTX Skill lets you build, edit and read `.pptx` and `.potx` slides, backed by supporting tools like `pptxgenjs`, OOXML decompression/editing scripts, `validate.py`, plus a three-tier QA pipeline. We'll walk through its positioning, core features, how to install it in Cursor and Claude Code, plus common workflows for template population, validation and visual QA along with key best practices.
Read MoreAnthropic PDF Skill: Enabling AI Programming Assistants to Truly Handle All Scenarios of PDF Processing
This PDF is an Agent Skill maintained officially by Anthropic, which follows the Agent Skills open standard and can be used in Cursor, Claude Code and Codex. It covers high-frequency office automation scenarios including PDF reading and extraction, merging and splitting, rotating and watermarking, form filling, encryption and decryption, OCR and image extraction, etc., and includes tool selection guides for pypdf, pdfplumber, reportlab, qpdf, pdftotext and other tools. This article introduces the positioning, core capabilities, installation methods in Claude Code/Cursor/Codex, as well as official code examples and usage notes of the Skill.
Read MoreSkill: Let AI Truly Write Deliverable Word Documents
DOCX is a Word document Agent Skill publicly released by Anthropic in the anthropics/skills repository, which supports Claude's file creation and editing capabilities. This article introduces its positioning, three technical paths of creation/reading/editing, revision annotations and bundled scripts, installation methods in Cursor and Claude Code, as well as precautions such as docx-js and unzip/XML editing, to help developers truly deliver AI-generated content into deliverable .docx files.
Read More# Claude-api Skill: A Pocket Reference Manual for Claude API Developers
Anthropic's open-source claude-api Agent Skill packages the documentation of Messages API, Managed Agents and 8 programming language SDKs including Python, TypeScript and Go into progressively loadable references, which is built into Claude Code. This article introduces its positioning, core capabilities (model migration, streaming, tool calling, Prompt Caching, MCP/Agent), installation method and typical usage, helping developers avoid writing outdated Claude API code from memory.
Read More# webapp-testing: Let AI Agents Autonomously Validate Local Web Applications with Playwright
Anthropic's official webapp-testing Skill wraps Playwright browser automation into reusable, agent-friendly test workflows. It supports starting local dev servers, taking screenshots to inspect DOM, and capturing console logs, and validates dynamic single-page applications following a "inspect first, then operate" pattern. This article introduces its core capabilities, installation methods in Cursor and Claude Code, as well as the multi-server management with `with_server.py` and typical Playwright script examples, to help developers enable AI to independently run UI regression tests after modifying front-end code.
Read Morefrontend-design: Making AI-generated interfaces no longer "cut from the same mold"
frontend-design is an Agent Skill officially maintained by Anthropic, targeting scenarios of building or retrofitting UIs. Through design planning, token system, typography and self-review process, it guides AI to avoid common default aesthetics such as warm beige serifs, dark neon colors and newspaper-style columns, and produce more recognizable interfaces. This article introduces its core principles, two-stage workflow, as well as installation and typical prompt usage in tools like Claude Code and Cursor.
Read More# MCP-Builder: Official Anthropic Skill to Walk You Through Building High-Quality MCP Servers
MCP-builder is an Agent Skill in Anthropic's official Skills repository, specifically designed to guide developers in creating high-quality MCP servers. Based on the official SKILL.md and reference documents, this article introduces its four-stage workflow (research and planning, implementation, testing, evaluation), dual-stack support for TypeScript/Python, installation and activation methods (Cursor, Claude Code, etc.), typical prompt examples and usage precautions, to help developers systematically encapsulate external APIs into LLM-callable MCP tools.
Read More